FHIR © HL7.org  |  Server Home  |  FHIR Server FHIR Server 3.4.11  |  FHIR Version n/a  User: [n/a]

Resource CodeSystem/FHIR Server from package hl7.fhir.uv.extensions#current (156 ms)

Package hl7.fhir.uv.extensions
Type CodeSystem
Id Id
FHIR Version R5
Source http://hl7.org/fhir/extensions/https://build.fhir.org/ig/HL7/fhir-extensions/CodeSystem-obligation.html
Url http://hl7.org/fhir/CodeSystem/obligation
Version 5.2.0-ballot
Status active
Date 2024-12-16T04:47:21+00:00
Name ObligationCodes
Title Obligation Codes
Experimental False
Realm uv
Authority hl7
Description Codes that describe application obligations for handling FHIR content. There are five kinds of codes in this code system: * Categorizer codes: ResourceProducerObligations, ResourcesExchangerObligations, and ResourceConsumerObligations which are used to construct value sets and indicate the contexts in which the obligations apply. Note that many applications will be producers, consumers, and potentially exchangers simultaneously, so there is no need to limit obligations to only one category. These are abstract and cannot be declared as obligations. * Qualifier codes: SHALL/SHOULD/MAY which convey the 'strength' of an obligation. These are also abstract and cannot be declared as obligations. * Generic codes - these describe abstract functional obligation behaviors applications may implement, but do not specify a specific strength. They may be organized in a hierarchy where one generic code specializes another. These are also abstract cannot be declared as obligations. * Leaf obligation codes - these are specific qualified obligations that can be declared by a data element and represent leaf-level obligations. They always inherit from a qualification concept and usually inherit from a functional code concept. These codes *can* be declared as obligations. * Composite codes - these specialise Leaf obligation codes, inheriting the expectations of multiple concrete obligations. They represent common or externally defined combinations of obligations for ease of reference. These codes can also be declared as obligations.
Content complete

Resources that use this resource

No resources found


Resources that this resource uses

No resources found



Narrative

Note: links and images are rebased to the (stated) source

Generated Narrative: CodeSystem obligation

Properties

This code system defines the following properties for its concepts

NameCodeURITypeDescription
Not Selectablenot-selectablehttp://hl7.org/fhir/concept-properties#notSelectablebooleanCodes with this property set are not intended to appear in instances. They are for grouping/subsetting purposes only.
Parentparenthttp://hl7.org/fhir/concept-properties#parentcode
qualifierqualifierhttp://hl7.org/fhir/CodeSystem/obligation#qualifiercodeIndicates the level of adherence expected to the obligation concept
converseconversehttp://hl7.org/fhir/CodeSystem/obligation#conversecodeIndicates another obligation code with an opposite meaning to this one. A single obligation cannot list two converse codes and an application cannot satisfy both a code and its coverse (though if the obligation strength for both is SHOULD or MAY, an application could conform with both obligations by adhering to one and not the other).
security-dependentsecurity-dependenthttp://hl7.org/fhir/CodeSystem/obligation#security-dependentbooleanObligation codes with this property set to true may be overridden by policies and regulations related to privacy and security, including patient consent. Testing of such obligations will need to take such considerations into account.

Concepts

This case-sensitive code system http://hl7.org/fhir/CodeSystem/obligation defines the following codes in a Is-A hierarchy:

CodeDisplayDefinitionNot SelectableParent
SHALL SHALL

The functional requirement is mandatory. Applications that do not implement this functional behavior are considered non-conformant.

true
SHOULD SHOULD

The functional requirement is a recommendation. Applications are strongly encouraged to implement this functional behavior, but are still conformant if they do not.

true
MAY MAY

The functional requirement is an option worthy of consideration but there is no expectation or recommendation associated with its use. NOTE: Elements not flagged with any obligation are intrinsically still 'MAY' (unless constraints dictate otherwise), but have not specifically been called out by the author as worthy of consideration.

true
ResourceProducerObligations ResourceProducerObligations

Resource producers are applications that assembles resources in the first place. Resource producers may be a server, client, sender, receiver or some middleware device, and they may store the resource, or merely hand it on.

true
ResourceExchangerObligations ResourceExchangerObligations

Exchangers do not produce or consume resources; they only pass the resource on. They may store the resource in a persistent store between reception and subsequent transfer. The generic FHIR servers are exchangers, as are most middleware systems. Note that Exchanger obligations may also be taken on by Producers or Consumers if they act as intermediaries between other systems or between systems and users.

true
ResourceConsumerObligations ResourceConsumerObligations

Resource Consumers are applications that consume resources and do something with them, either displaying them to humans, transferring them to some other format for further re-use, or using them to drive some kind of application logic process AKA decision support. Resource Consumers often store resources, but do not need to, and whether resources are stored or not between receiving them and using them doesn't make any difference to the obligations

true
able-to-populate be able to populate

Conformant applications producing resources SHALL/SHOULD/MAY be able to correctly populate this element. Notes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.

trueResourceProducerObligations
populate-if-known populate if known

Conformant applications producing resources SHALL/SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element. Notes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.

trueResourceProducerObligations
populate populate

Conformant applications producing resources SHALL/SHOULD include this element if a value is known and allowed to be shared. Notes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.

truepopulate-if-known, able-to-populate
in-narrative include in narrative

Conformant applications SHALL/SHOULD/MAY ensure that this data element is represented in any human readable representation of a resource. Notes: When no value for an element is known, the producer populates the narrative with the content of any nested ElementDefinition.valueAlternatives extensions such as DataAbsentReason. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.

trueResourceProducerObligations
exclude-narrative exclude from narrative

Conformant applications SHALL/SHOULD ensure that this data element is NOT represented in any human readable representation of a resource. Notes: This may be useful for profiles related to de-identified records

trueResourceProducerObligations
user-input allow user input

Conformant applications SHALL/SHOULD/MAY ensure that users can enter a value for this element during data input/capture. Notes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.

trueResourceProducerObligations
explain populate or document irrelevance

Documentation applicable to Conformant applications SHALL/SHOULD explain how this element is handled. Notes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element populate, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though not all) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.

trueResourceProducerObligations
persist persist

Conformant applications SHALL/SHOULD/MAY ensure that the value for this element is stored in a persistent data store. Notes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges

trueResourceConsumerObligations, ResourceProducerObligations
no-alter not alter

Conformant applications SHALL/SHOULD ensure that this element does not change between receiving and transfer. Notes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply

trueResourceExchangerObligations
no-error not error if present

Conformant applications SHALL/SHOULD accept resources containing any valid value for the element without error. Notes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations

trueResourceConsumerObligations
reject-invalid reject invalid

Conformant applications SHALL/SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL/SHOULD not accept the instance. Notes: This applies to validating the element with the obligation, but not resources referenced by it.

trueResourceConsumerObligations
accept-invalid accept invalid

Conformant applications SHALL/SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation. This applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)

trueResourceConsumerObligations
handle correctly handle

Conformant applications SHALL/SHOULD handle the meaning of this element correctly. Notes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.

trueResourceConsumerObligations
display display

Conformant applications SHALL/SHOULD/MAY display the value of this element when presenting the data from the resource to a human user. Notes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource

truehandle
process process

Conformant applications SHALL/SHOULD/MAY consider the value of this element when processing the resource as specified by the IG. Notes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any ElementDefinition.valueAlternatives extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.

truehandle
print print

Conformant applications SHALL/SHOULD/MAY print the value of this element somewhere. Notes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow

truehandle
ignore ignore

Conformant applications SHALL/SHOULD/MAY not make any use of the value of this element if received.

trueResourceConsumerObligations
SHALL:able-to-populate SHALL be able to populate

Conformant applications producing resources SHALL be able to correctly populate this element. Notes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.

able-to-populate
SHOULD:able-to-populate SHOULD be able to populate

Conformant applications producing resources SHOULD be able to correctly populate this element. Notes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it shold be in at least some situations.

able-to-populate
MAY:able-to-populate MAY be able to populate

Conformant applications producing resources MAY be able to correctly populate this element. Notes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it may be in at least some situations. This is a null statement and is the default behavior for originating systems if other obligations are not specified.

able-to-populate
SHALL:populate-if-known SHALL populate if known

Conformant applications producing resources SHALL correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element. Notes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.

populate-if-known
SHOULD:populate-if-known SHOULD populate if known

Conformant applications producing resources SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element. Notes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.

populate-if-known
SHALL:populate SHALL populate

Conformant applications producing resources SHALL include this element if a value is known and allowed to be shared. Notes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.

SHALL:able-to-populate, populate
SHOULD:populate SHOULD populate

Conformant applications producing resources SHOULD include this element if a value is known and allowed to be shared. Notes: This implementation obligation means that whenever the producer knows the correct value for an element, it should populate it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.

SHOULD:able-to-populate, populate
SHALL:in-narrative SHALL include in narrative

Conformant applications SHALL ensure that this data element is represented in any human readable representation of a resource. Notes: When no value for an element is known, the producer populates the narrative with the content of any nested ElementDefinition.valueAlternatives extensions such as DataAbsentReason. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.

in-narrative
SHOULD:in-narrative SHOULD include in narrative

Conformant applications SHOULD ensure that this data element is represented in any human readable representation of a resource. Notes: When no value for an element is known, the producer populates the narrative with the content of any nested ElementDefinition.valueAlternatives extensions such as DataAbsentReason. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.

in-narrative
MAY:in-narrative MAY include in narrative

Conformant applications MAY ensure that this data element is represented in any human readable representation of a resource. Notes: When no value for an element is known, the producer populates the narrative with the content of any nested ElementDefinition.valueAlternatives extensions such as DataAbsentReason. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.

in-narrative
SHALL:exclude-narrative SHALL exclude from narrative

Conformant applications SHALL ensure that this data element is NOT represented in any human readable representation of a resource. Notes: This may be useful for profiles related to de-identified records

exclude-narrative
SHOULD:exclude-narrative SHOULD exclude from narrative

Conformant applications SHOULD ensure that this data element is NOT represented in any human readable representation of a resource. Notes: This may be useful for profiles related to de-identified records

exclude-narrative
SHALL:user-input SHALL allow user input

Conformant applications SHALL ensure that users can enter a value for this element during data input/capture. Notes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.

user-input
SHOULD:user-input SHOULD allow user input

Conformant applications SHOULD ensure that users can enter a value for this element during data input/capture. Notes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.

user-input
MAY:user-input MAY allow user input

Conformant applications MAY ensure that users can enter a value for this element during data input/capture. Notes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.

user-input
SHALL:explain SHALL populate or document irrelevance

Documentation applicable to Conformant applications SHALL explain how this element is handled. Notes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element populate, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though not all) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.

explain
SHOULD:explain SHOULD populate or document irrelevance

Documentation applicable to Conformant applications SHOULD explain how this element is handled. Notes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element populate, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though not all) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.

explain
SHALL:persist SHALL persist

Conformant applications SHALL ensure that the value for this element is stored in a persistent data store. Notes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges

persist
SHOULD:persist SHOULD persist

Conformant applications SHOULD ensure that the value for this element is stored in a persistent data store. Notes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges

persist
MAY:persist MAY persist

Conformant applications MAY ensure that the value for this element is stored in a persistent data store. Notes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges

persist
SHALL:no-alter SHALL not alter

Conformant applications SHALL ensure that this element does not change between receiving and transfer. Notes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply

no-alter
SHOULD:no-alter SHOULD not alter

Conformant applications SHOULD ensure that this element does not change between receiving and transfer. Notes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply

no-alter
MAY:alter MAY alter

Conformant applications MAY choose to alter this element value. Notes: this is really a null-statement - it's the default rule for an application. It's defined here to allow a specification to be explicit that it isn't conveying obligations for resource producers

ResourceExchangerObligations
SHALL:no-error SHALL not error if present

Conformant applications SHALL accept resources containing any valid value for the element without error. Notes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations

no-error
SHOULD:no-error SHOULD not error if present

Conformant applications SHOULD accept resources containing any valid value for the element without error. Notes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations

no-error
SHALL:reject-invalid SHALL reject invalid

Conformant applications SHALL check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL not accept the instance. Notes: This applies to validating the element with the obligation, but not resources referenced by it.

reject-invalid
SHOULD:reject-invalid SHOULD reject invalid

Conformant applications SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHOULD not accept the instance. Notes: This applies to validating the element with the obligation, but not resources referenced by it.

reject-invalid
SHALL:accept-invalid SHALL accept invalid

Conformant applications SHALL accept data that does not meet all data constraints asserted within the profile declaring this obligation. This applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)

accept-invalid
SHOULD:accept-invalid SHOULD accept invalid

Conformant applications SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation. This applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system ought to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)

accept-invalid
SHALL:handle SHALL correctly handle

Conformant applications SHALL handle the meaning of this element correctly. Notes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.

handle
SHOULD:handle SHOULD correctly handle

Conformant applications SHOULD handle the meaning of this element correctly. Notes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.

handle
SHALL:display SHALL display

Conformant applications SHALL display the value of this element when presenting the data from the resource to a human user. Notes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource

SHALL:handle, display
SHOULD:display SHOULD display

Conformant applications SHOULD display the value of this element when presenting the data from the resource to a human user. Notes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource

SHOULD:handle, display
MAY:display MAY display

Conformant applications MAY display the value of this element when presenting the data from the resource to a human user. Notes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource

display
SHALL:process SHALL process

Conformant applications SHALL consider the value of this element when processing the resource as specified by the IG. Notes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any ElementDefinition.valueAlternatives extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.

SHALL:handle, process
SHOULD:process SHOULD process

Conformant applications SHOULD consider the value of this element when processing the resource as specified by the IG. Notes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any ElementDefinition.valueAlternatives extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.

SHOULD:handle, process
MAY:process MAY process

Conformant applications MAY consider the value of this element when processing the resource as specified by the IG. Notes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any ElementDefinition.valueAlternatives extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.

process
SHALL:print SHALL print

Conformant applications SHALL print the value of this element somewhere. Notes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow

SHALL:handle, print
SHOULD:print SHOULD print

Conformant applications SHOULD print the value of this element somewhere. Notes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow

SHOULD:handle, print
MAY:print MAY print

Conformant applications MAY print the value of this element somewhere. Notes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow

print
SHALL:ignore SHALL ignore

Conformant applications SHALL not make any use of the value of this element if received.

ignore
SHOULD:ignore SHOULD ignore

Conformant applications SHOULD not make any use of the value of this element if received.

ignore
MAY:ignore MAY ignore

Conformant applications MAY not make any use of the value of this element if received. This is a null statement and is the default behavior or consuming systems if other obligations are not specified.

ignore
v2-re V2 RE (required but may be empty)

RE as defined in chapter 2 of the v2 specification

SHALL:able-to-populate, SHALL:display, SHOULD:persist, SHOULD:populate, SHALL:no-error
ihe-r2 IHE R2

R2 as defined in IHE Appendix Z

SHALL:populate, MAY:ignore, SHALL:no-error
std Standard obligations

The standard recommended set of obligations for IGs to use unless they know they want something different. Note that the standard codes don't include use-dar, use-dar-nf, use-dar-if-allowed / use-reason - that gets put on specific elements that justify this handling

SHALL:populate, SHALL:display, SHALL:no-error

Source

{
  "resourceType" : "CodeSystem",
  "id" : "obligation",
  "text" : {
    "status" : "generated",
    "div" : "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p class=\"res-header-id\"><b>Generated Narrative: CodeSystem obligation</b></p><a name=\"obligation\"> </a><a name=\"hcobligation\"> </a><a name=\"obligation-en-US\"> </a><p><b>Properties</b></p><p><b>This code system defines the following properties for its concepts</b></p><table class=\"grid\"><tr><td><b>Name</b></td><td><b>Code</b></td><td><b>URI</b></td><td><b>Type</b></td><td><b>Description</b></td></tr><tr><td>Not Selectable</td><td>not-selectable</td><td>http://hl7.org/fhir/concept-properties#notSelectable</td><td>boolean</td><td>Codes with this property set are not intended to appear in instances. They are for grouping/subsetting purposes only.</td></tr><tr><td>Parent</td><td>parent</td><td>http://hl7.org/fhir/concept-properties#parent</td><td>code</td><td/></tr><tr><td>qualifier</td><td>qualifier</td><td>http://hl7.org/fhir/CodeSystem/obligation#qualifier</td><td>code</td><td>Indicates the level of adherence expected to the obligation concept</td></tr><tr><td>converse</td><td>converse</td><td>http://hl7.org/fhir/CodeSystem/obligation#converse</td><td>code</td><td>Indicates another obligation code with an opposite meaning to this one. A single obligation cannot list two converse codes and an application cannot satisfy both a code and its coverse (though if the obligation strength for both is SHOULD or MAY, an application could conform with both obligations by adhering to one and not the other).</td></tr><tr><td>security-dependent</td><td>security-dependent</td><td>http://hl7.org/fhir/CodeSystem/obligation#security-dependent</td><td>boolean</td><td>Obligation codes with this property set to true may be overridden by policies and regulations related to privacy and security, including patient consent. Testing of such obligations will need to take such considerations into account.</td></tr></table><p><b>Concepts</b></p><p>This case-sensitive code system <code>http://hl7.org/fhir/CodeSystem/obligation</code> defines the following codes in a Is-A hierarchy:</p><table class=\"codes\"><tr><td style=\"white-space:nowrap\"><b>Code</b></td><td><b>Display</b></td><td><b>Definition</b></td><td><b>Not Selectable</b></td><td><b>Parent</b></td></tr><tr><td style=\"white-space:nowrap\">SHALL<a name=\"obligation-SHALL\"> </a></td><td>SHALL</td><td><div><p>The functional requirement is mandatory. Applications that do not implement this functional behavior are considered non-conformant.</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">SHOULD<a name=\"obligation-SHOULD\"> </a></td><td>SHOULD</td><td><div><p>The functional requirement is a recommendation. Applications are strongly encouraged to implement this functional behavior, but are still conformant if they do not.</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">MAY<a name=\"obligation-MAY\"> </a></td><td>MAY</td><td><div><p>The functional requirement is an option worthy of consideration but there is no expectation or recommendation associated with its use. NOTE: Elements not flagged with any obligation are intrinsically still 'MAY' (unless constraints dictate otherwise), but have not specifically been called out by the author as worthy of consideration.</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">ResourceProducerObligations<a name=\"obligation-ResourceProducerObligations\"> </a></td><td>ResourceProducerObligations</td><td><div><p>Resource producers are applications that assembles resources in the first place. Resource producers may be a server, client, sender, receiver or some middleware device, and they may store the resource, or merely hand it on.</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">ResourceExchangerObligations<a name=\"obligation-ResourceExchangerObligations\"> </a></td><td>ResourceExchangerObligations</td><td><div><p>Exchangers do not produce or consume resources; they only pass the resource on. They may store the resource in a persistent store between reception and subsequent transfer. The generic FHIR servers are exchangers, as are most middleware systems. Note that Exchanger obligations may also be taken on by Producers or Consumers if they act as intermediaries between other systems or between systems and users.</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">ResourceConsumerObligations<a name=\"obligation-ResourceConsumerObligations\"> </a></td><td>ResourceConsumerObligations</td><td><div><p>Resource Consumers are applications that consume resources and do something with them, either displaying them to humans, transferring them to some other format for further re-use, or using them to drive some kind of application logic process AKA decision support. Resource Consumers often store resources, but do not need to, and whether resources are stored or not between receiving them and using them doesn't make any difference to the obligations</p>\n</div></td><td>true</td><td/></tr><tr><td style=\"white-space:nowrap\">able-to-populate<a name=\"obligation-able-to-populate\"> </a></td><td>be able to populate</td><td><div><p>Conformant applications producing resources SHALL/SHOULD/MAY be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">populate-if-known<a name=\"obligation-populate-if-known\"> </a></td><td>populate if known</td><td><div><p>Conformant applications producing resources SHALL/SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">populate<a name=\"obligation-populate\"> </a></td><td>populate</td><td><div><p>Conformant applications producing resources SHALL/SHOULD include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.</p>\n</div></td><td>true</td><td><a href=\"#obligation-populate-if-known\">populate-if-known</a>, <a href=\"#obligation-able-to-populate\">able-to-populate</a></td></tr><tr><td style=\"white-space:nowrap\">in-narrative<a name=\"obligation-in-narrative\"> </a></td><td>include in narrative</td><td><div><p>Conformant applications SHALL/SHOULD/MAY ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions such as <a href=\"StructureDefinition-data-absent-reason.html\">DataAbsentReason</a>. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">exclude-narrative<a name=\"obligation-exclude-narrative\"> </a></td><td>exclude from narrative</td><td><div><p>Conformant applications SHALL/SHOULD ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">user-input<a name=\"obligation-user-input\"> </a></td><td>allow user input</td><td><div><p>Conformant applications SHALL/SHOULD/MAY ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">explain<a name=\"obligation-explain\"> </a></td><td>populate or document irrelevance</td><td><div><p>Documentation applicable to Conformant applications SHALL/SHOULD explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element <code>populate</code>, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though <em>not all</em>) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">persist<a name=\"obligation-persist\"> </a></td><td>persist</td><td><div><p>Conformant applications SHALL/SHOULD/MAY ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a>, <a href=\"#obligation-ResourceProducerObligations\">ResourceProducerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">no-alter<a name=\"obligation-no-alter\"> </a></td><td>not alter</td><td><div><p>Conformant applications SHALL/SHOULD ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceExchangerObligations\">ResourceExchangerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">no-error<a name=\"obligation-no-error\"> </a></td><td>not error if present</td><td><div><p>Conformant applications SHALL/SHOULD accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">reject-invalid<a name=\"obligation-reject-invalid\"> </a></td><td>reject invalid</td><td><div><p>Conformant applications SHALL/SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL/SHOULD not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">accept-invalid<a name=\"obligation-accept-invalid\"> </a></td><td>accept invalid</td><td><div><p>Conformant applications SHALL/SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">handle<a name=\"obligation-handle\"> </a></td><td>correctly handle</td><td><div><p>Conformant applications SHALL/SHOULD handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">display<a name=\"obligation-display\"> </a></td><td>display</td><td><div><p>Conformant applications SHALL/SHOULD/MAY display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource</p>\n</div></td><td>true</td><td><a href=\"#obligation-handle\">handle</a></td></tr><tr><td style=\"white-space:nowrap\">process<a name=\"obligation-process\"> </a></td><td>process</td><td><div><p>Conformant applications SHALL/SHOULD/MAY consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.</p>\n</div></td><td>true</td><td><a href=\"#obligation-handle\">handle</a></td></tr><tr><td style=\"white-space:nowrap\">print<a name=\"obligation-print\"> </a></td><td>print</td><td><div><p>Conformant applications SHALL/SHOULD/MAY print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow</p>\n</div></td><td>true</td><td><a href=\"#obligation-handle\">handle</a></td></tr><tr><td style=\"white-space:nowrap\">ignore<a name=\"obligation-ignore\"> </a></td><td>ignore</td><td><div><p>Conformant applications SHALL/SHOULD/MAY not make any use of the value of this element if received.</p>\n</div></td><td>true</td><td><a href=\"#obligation-ResourceConsumerObligations\">ResourceConsumerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:able-to-populate<a name=\"obligation-SHALL.58able-to-populate\"> </a></td><td>SHALL be able to populate</td><td><div><p>Conformant applications producing resources SHALL be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.</p>\n</div></td><td/><td><a href=\"#obligation-able-to-populate\">able-to-populate</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:able-to-populate<a name=\"obligation-SHOULD.58able-to-populate\"> </a></td><td>SHOULD be able to populate</td><td><div><p>Conformant applications producing resources SHOULD be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it shold be in at least some situations.</p>\n</div></td><td/><td><a href=\"#obligation-able-to-populate\">able-to-populate</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:able-to-populate<a name=\"obligation-MAY.58able-to-populate\"> </a></td><td>MAY be able to populate</td><td><div><p>Conformant applications producing resources MAY be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it may be in at least some situations. This is a null statement and is the default behavior for originating systems if other obligations are not specified.</p>\n</div></td><td/><td><a href=\"#obligation-able-to-populate\">able-to-populate</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:populate-if-known<a name=\"obligation-SHALL.58populate-if-known\"> </a></td><td>SHALL populate if known</td><td><div><p>Conformant applications producing resources SHALL correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.</p>\n</div></td><td/><td><a href=\"#obligation-populate-if-known\">populate-if-known</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:populate-if-known<a name=\"obligation-SHOULD.58populate-if-known\"> </a></td><td>SHOULD populate if known</td><td><div><p>Conformant applications producing resources SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.</p>\n</div></td><td/><td><a href=\"#obligation-populate-if-known\">populate-if-known</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:populate<a name=\"obligation-SHALL.58populate\"> </a></td><td>SHALL populate</td><td><div><p>Conformant applications producing resources SHALL include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58able-to-populate\">SHALL:able-to-populate</a>, <a href=\"#obligation-populate\">populate</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:populate<a name=\"obligation-SHOULD.58populate\"> </a></td><td>SHOULD populate</td><td><div><p>Conformant applications producing resources SHOULD include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it should populate it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.</p>\n</div></td><td/><td><a href=\"#obligation-SHOULD.58able-to-populate\">SHOULD:able-to-populate</a>, <a href=\"#obligation-populate\">populate</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:in-narrative<a name=\"obligation-SHALL.58in-narrative\"> </a></td><td>SHALL include in narrative</td><td><div><p>Conformant applications SHALL ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions such as <a href=\"StructureDefinition-data-absent-reason.html\">DataAbsentReason</a>. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.</p>\n</div></td><td/><td><a href=\"#obligation-in-narrative\">in-narrative</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:in-narrative<a name=\"obligation-SHOULD.58in-narrative\"> </a></td><td>SHOULD include in narrative</td><td><div><p>Conformant applications SHOULD ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions such as <a href=\"StructureDefinition-data-absent-reason.html\">DataAbsentReason</a>. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.</p>\n</div></td><td/><td><a href=\"#obligation-in-narrative\">in-narrative</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:in-narrative<a name=\"obligation-MAY.58in-narrative\"> </a></td><td>MAY include in narrative</td><td><div><p>Conformant applications MAY ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions such as <a href=\"StructureDefinition-data-absent-reason.html\">DataAbsentReason</a>. If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.</p>\n</div></td><td/><td><a href=\"#obligation-in-narrative\">in-narrative</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:exclude-narrative<a name=\"obligation-SHALL.58exclude-narrative\"> </a></td><td>SHALL exclude from narrative</td><td><div><p>Conformant applications SHALL ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records</p>\n</div></td><td/><td><a href=\"#obligation-exclude-narrative\">exclude-narrative</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:exclude-narrative<a name=\"obligation-SHOULD.58exclude-narrative\"> </a></td><td>SHOULD exclude from narrative</td><td><div><p>Conformant applications SHOULD ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records</p>\n</div></td><td/><td><a href=\"#obligation-exclude-narrative\">exclude-narrative</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:user-input<a name=\"obligation-SHALL.58user-input\"> </a></td><td>SHALL allow user input</td><td><div><p>Conformant applications SHALL ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.</p>\n</div></td><td/><td><a href=\"#obligation-user-input\">user-input</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:user-input<a name=\"obligation-SHOULD.58user-input\"> </a></td><td>SHOULD allow user input</td><td><div><p>Conformant applications SHOULD ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.</p>\n</div></td><td/><td><a href=\"#obligation-user-input\">user-input</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:user-input<a name=\"obligation-MAY.58user-input\"> </a></td><td>MAY allow user input</td><td><div><p>Conformant applications MAY ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.</p>\n</div></td><td/><td><a href=\"#obligation-user-input\">user-input</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:explain<a name=\"obligation-SHALL.58explain\"> </a></td><td>SHALL populate or document irrelevance</td><td><div><p>Documentation applicable to Conformant applications SHALL explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element <code>populate</code>, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though <em>not all</em>) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.</p>\n</div></td><td/><td><a href=\"#obligation-explain\">explain</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:explain<a name=\"obligation-SHOULD.58explain\"> </a></td><td>SHOULD populate or document irrelevance</td><td><div><p>Documentation applicable to Conformant applications SHOULD explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element <code>populate</code>, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though <em>not all</em>) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.</p>\n</div></td><td/><td><a href=\"#obligation-explain\">explain</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:persist<a name=\"obligation-SHALL.58persist\"> </a></td><td>SHALL persist</td><td><div><p>Conformant applications SHALL ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges</p>\n</div></td><td/><td><a href=\"#obligation-persist\">persist</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:persist<a name=\"obligation-SHOULD.58persist\"> </a></td><td>SHOULD persist</td><td><div><p>Conformant applications SHOULD ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges</p>\n</div></td><td/><td><a href=\"#obligation-persist\">persist</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:persist<a name=\"obligation-MAY.58persist\"> </a></td><td>MAY persist</td><td><div><p>Conformant applications MAY ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges</p>\n</div></td><td/><td><a href=\"#obligation-persist\">persist</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:no-alter<a name=\"obligation-SHALL.58no-alter\"> </a></td><td>SHALL not alter</td><td><div><p>Conformant applications SHALL ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply</p>\n</div></td><td/><td><a href=\"#obligation-no-alter\">no-alter</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:no-alter<a name=\"obligation-SHOULD.58no-alter\"> </a></td><td>SHOULD not alter</td><td><div><p>Conformant applications SHOULD ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply</p>\n</div></td><td/><td><a href=\"#obligation-no-alter\">no-alter</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:alter<a name=\"obligation-MAY.58alter\"> </a></td><td>MAY alter</td><td><div><p>Conformant applications MAY choose to alter this element value.\nNotes: this is really a null-statement - it's the default rule for an application. It's defined here to allow a specification to be explicit that it isn't conveying obligations for resource producers</p>\n</div></td><td/><td><a href=\"#obligation-ResourceExchangerObligations\">ResourceExchangerObligations</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:no-error<a name=\"obligation-SHALL.58no-error\"> </a></td><td>SHALL not error if present</td><td><div><p>Conformant applications SHALL accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations</p>\n</div></td><td/><td><a href=\"#obligation-no-error\">no-error</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:no-error<a name=\"obligation-SHOULD.58no-error\"> </a></td><td>SHOULD not error if present</td><td><div><p>Conformant applications SHOULD accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations</p>\n</div></td><td/><td><a href=\"#obligation-no-error\">no-error</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:reject-invalid<a name=\"obligation-SHALL.58reject-invalid\"> </a></td><td>SHALL reject invalid</td><td><div><p>Conformant applications SHALL check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.</p>\n</div></td><td/><td><a href=\"#obligation-reject-invalid\">reject-invalid</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:reject-invalid<a name=\"obligation-SHOULD.58reject-invalid\"> </a></td><td>SHOULD reject invalid</td><td><div><p>Conformant applications SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHOULD not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.</p>\n</div></td><td/><td><a href=\"#obligation-reject-invalid\">reject-invalid</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:accept-invalid<a name=\"obligation-SHALL.58accept-invalid\"> </a></td><td>SHALL accept invalid</td><td><div><p>Conformant applications SHALL accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)</p>\n</div></td><td/><td><a href=\"#obligation-accept-invalid\">accept-invalid</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:accept-invalid<a name=\"obligation-SHOULD.58accept-invalid\"> </a></td><td>SHOULD accept invalid</td><td><div><p>Conformant applications SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system ought to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)</p>\n</div></td><td/><td><a href=\"#obligation-accept-invalid\">accept-invalid</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:handle<a name=\"obligation-SHALL.58handle\"> </a></td><td>SHALL correctly handle</td><td><div><p>Conformant applications SHALL handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.</p>\n</div></td><td/><td><a href=\"#obligation-handle\">handle</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:handle<a name=\"obligation-SHOULD.58handle\"> </a></td><td>SHOULD correctly handle</td><td><div><p>Conformant applications SHOULD handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.</p>\n</div></td><td/><td><a href=\"#obligation-handle\">handle</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:display<a name=\"obligation-SHALL.58display\"> </a></td><td>SHALL display</td><td><div><p>Conformant applications SHALL display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58handle\">SHALL:handle</a>, <a href=\"#obligation-display\">display</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:display<a name=\"obligation-SHOULD.58display\"> </a></td><td>SHOULD display</td><td><div><p>Conformant applications SHOULD display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource</p>\n</div></td><td/><td><a href=\"#obligation-SHOULD.58handle\">SHOULD:handle</a>, <a href=\"#obligation-display\">display</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:display<a name=\"obligation-MAY.58display\"> </a></td><td>MAY display</td><td><div><p>Conformant applications MAY display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource</p>\n</div></td><td/><td><a href=\"#obligation-display\">display</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:process<a name=\"obligation-SHALL.58process\"> </a></td><td>SHALL process</td><td><div><p>Conformant applications SHALL consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58handle\">SHALL:handle</a>, <a href=\"#obligation-process\">process</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:process<a name=\"obligation-SHOULD.58process\"> </a></td><td>SHOULD process</td><td><div><p>Conformant applications SHOULD consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.</p>\n</div></td><td/><td><a href=\"#obligation-SHOULD.58handle\">SHOULD:handle</a>, <a href=\"#obligation-process\">process</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:process<a name=\"obligation-MAY.58process\"> </a></td><td>MAY process</td><td><div><p>Conformant applications MAY consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any <a href=\"http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives\">ElementDefinition.valueAlternatives</a> extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.</p>\n</div></td><td/><td><a href=\"#obligation-process\">process</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:print<a name=\"obligation-SHALL.58print\"> </a></td><td>SHALL print</td><td><div><p>Conformant applications SHALL print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58handle\">SHALL:handle</a>, <a href=\"#obligation-print\">print</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:print<a name=\"obligation-SHOULD.58print\"> </a></td><td>SHOULD print</td><td><div><p>Conformant applications SHOULD print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow</p>\n</div></td><td/><td><a href=\"#obligation-SHOULD.58handle\">SHOULD:handle</a>, <a href=\"#obligation-print\">print</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:print<a name=\"obligation-MAY.58print\"> </a></td><td>MAY print</td><td><div><p>Conformant applications MAY print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow</p>\n</div></td><td/><td><a href=\"#obligation-print\">print</a></td></tr><tr><td style=\"white-space:nowrap\">SHALL:ignore<a name=\"obligation-SHALL.58ignore\"> </a></td><td>SHALL ignore</td><td><div><p>Conformant applications SHALL not make any use of the value of this element if received.</p>\n</div></td><td/><td><a href=\"#obligation-ignore\">ignore</a></td></tr><tr><td style=\"white-space:nowrap\">SHOULD:ignore<a name=\"obligation-SHOULD.58ignore\"> </a></td><td>SHOULD ignore</td><td><div><p>Conformant applications SHOULD not make any use of the value of this element if received.</p>\n</div></td><td/><td><a href=\"#obligation-ignore\">ignore</a></td></tr><tr><td style=\"white-space:nowrap\">MAY:ignore<a name=\"obligation-MAY.58ignore\"> </a></td><td>MAY ignore</td><td><div><p>Conformant applications MAY not make any use of the value of this element if received. This is a null statement and is the default behavior or consuming systems if other obligations are not specified.</p>\n</div></td><td/><td><a href=\"#obligation-ignore\">ignore</a></td></tr><tr><td style=\"white-space:nowrap\">v2-re<a name=\"obligation-v2-re\"> </a></td><td>V2 RE (required but may be empty)</td><td><div><p>RE as defined in chapter 2 of the v2 specification</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58able-to-populate\">SHALL:able-to-populate</a>, <a href=\"#obligation-SHALL.58display\">SHALL:display</a>, <a href=\"#obligation-SHOULD.58persist\">SHOULD:persist</a>, <a href=\"#obligation-SHOULD.58populate\">SHOULD:populate</a>, <a href=\"#obligation-SHALL.58no-error\">SHALL:no-error</a></td></tr><tr><td style=\"white-space:nowrap\">ihe-r2<a name=\"obligation-ihe-r2\"> </a></td><td>IHE R2</td><td><div><p>R2 as defined in IHE Appendix Z</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58populate\">SHALL:populate</a>, <a href=\"#obligation-MAY.58ignore\">MAY:ignore</a>, <a href=\"#obligation-SHALL.58no-error\">SHALL:no-error</a></td></tr><tr><td style=\"white-space:nowrap\">std<a name=\"obligation-std\"> </a></td><td>Standard obligations</td><td><div><p>The standard recommended set of obligations for IGs to use unless they know they want something different. Note that the standard codes don't include use-dar, use-dar-nf, use-dar-if-allowed / use-reason - that gets put on specific elements that justify this handling</p>\n</div></td><td/><td><a href=\"#obligation-SHALL.58populate\">SHALL:populate</a>, <a href=\"#obligation-SHALL.58display\">SHALL:display</a>, <a href=\"#obligation-SHALL.58no-error\">SHALL:no-error</a></td></tr></table></div>"
  },
  "extension" : [
    {
      "url" : "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
      "valueCode" : "trial-use"
    },
    {
      "url" : "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
      "valueCode" : "fhir"
    },
    {
      "url" : "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
      "valueInteger" : 1,
      "_valueInteger" : {
        "extension" : [
          {
            "url" : "http://hl7.org/fhir/StructureDefinition/structuredefinition-conformance-derivedFrom",
            "valueCanonical" : "http://hl7.org/fhir/extensions/ImplementationGuide/hl7.fhir.uv.extensions"
          }
        ]
      }
    }
  ],
  "url" : "http://hl7.org/fhir/CodeSystem/obligation",
  "identifier" : [
    {
      "system" : "urn:ietf:rfc:3986",
      "value" : "urn:oid:2.16.840.1.113883.4.642.4.2123"
    }
  ],
  "version" : "5.2.0-ballot",
  "name" : "ObligationCodes",
  "title" : "Obligation Codes",
  "status" : "active",
  "experimental" : false,
  "date" : "2024-12-16T04:47:21+00:00",
  "publisher" : "HL7 International / FHIR Infrastructure",
  "contact" : [
    {
      "telecom" : [
        {
          "system" : "url",
          "value" : "http://www.hl7.org/Special/committees/fiwg"
        }
      ]
    }
  ],
  "description" : "Codes that describe application obligations for handling FHIR content. There are five kinds of codes in this code system:\n * Categorizer codes: ResourceProducerObligations, ResourcesExchangerObligations, and ResourceConsumerObligations which are used to construct value sets and indicate the contexts in which the obligations apply. Note that many applications will be producers, consumers, and potentially exchangers simultaneously, so there is no need to limit obligations to only one category. These are abstract and cannot be declared as obligations.\n * Qualifier codes: SHALL/SHOULD/MAY which convey the 'strength' of an obligation. These are also abstract and cannot be declared as obligations.\n * Generic codes - these describe abstract functional obligation behaviors applications may implement, but do not specify a specific strength. They may be organized in a hierarchy where one generic code specializes another. These are also abstract cannot be declared as obligations.\n * Leaf obligation codes - these are specific qualified obligations that can be declared by a data element and represent leaf-level obligations. They always inherit from a qualification concept and usually inherit from a functional code concept. These codes *can* be declared as obligations.\n * Composite codes - these specialise Leaf obligation codes, inheriting the expectations of multiple concrete obligations. They represent common or externally defined combinations of obligations for ease of reference. These codes can also be declared as obligations.",
  "jurisdiction" : [
    {
      "coding" : [
        {
          "system" : "http://unstats.un.org/unsd/methods/m49/m49.htm",
          "code" : "001"
        }
      ]
    }
  ],
  "caseSensitive" : true,
  "hierarchyMeaning" : "is-a",
  "compositional" : true,
  "content" : "complete",
  "property" : [
    {
      "code" : "not-selectable",
      "uri" : "http://hl7.org/fhir/concept-properties#notSelectable",
      "description" : "Codes with this property set are not intended to appear in instances. They are for grouping/subsetting purposes only.",
      "type" : "boolean"
    },
    {
      "code" : "parent",
      "uri" : "http://hl7.org/fhir/concept-properties#parent",
      "type" : "code"
    },
    {
      "code" : "qualifier",
      "uri" : "http://hl7.org/fhir/CodeSystem/obligation#qualifier",
      "description" : "Indicates the level of adherence expected to the obligation concept",
      "type" : "code"
    },
    {
      "code" : "converse",
      "uri" : "http://hl7.org/fhir/CodeSystem/obligation#converse",
      "description" : "Indicates another obligation code with an opposite meaning to this one. A single obligation cannot list two converse codes and an application cannot satisfy both a code and its coverse (though if the obligation strength for both is SHOULD or MAY, an application could conform with both obligations by adhering to one and not the other).",
      "type" : "code"
    },
    {
      "code" : "security-dependent",
      "uri" : "http://hl7.org/fhir/CodeSystem/obligation#security-dependent",
      "description" : "Obligation codes with this property set to true may be overridden by policies and regulations related to privacy and security, including patient consent. Testing of such obligations will need to take such considerations into account.",
      "type" : "boolean"
    }
  ],
  "concept" : [
    {
      "code" : "SHALL",
      "display" : "SHALL",
      "definition" : "The functional requirement is mandatory. Applications that do not implement this functional behavior are considered non-conformant.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD",
      "display" : "SHOULD",
      "definition" : "The functional requirement is a recommendation. Applications are strongly encouraged to implement this functional behavior, but are still conformant if they do not.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "MAY",
      "display" : "MAY",
      "definition" : "The functional requirement is an option worthy of consideration but there is no expectation or recommendation associated with its use. NOTE: Elements not flagged with any obligation are intrinsically still 'MAY' (unless constraints dictate otherwise), but have not specifically been called out by the author as worthy of consideration.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "ResourceProducerObligations",
      "display" : "ResourceProducerObligations",
      "definition" : "Resource producers are applications that assembles resources in the first place. Resource producers may be a server, client, sender, receiver or some middleware device, and they may store the resource, or merely hand it on.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "ResourceExchangerObligations",
      "display" : "ResourceExchangerObligations",
      "definition" : "Exchangers do not produce or consume resources; they only pass the resource on. They may store the resource in a persistent store between reception and subsequent transfer. The generic FHIR servers are exchangers, as are most middleware systems. Note that Exchanger obligations may also be taken on by Producers or Consumers if they act as intermediaries between other systems or between systems and users.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "ResourceConsumerObligations",
      "display" : "ResourceConsumerObligations",
      "definition" : "Resource Consumers are applications that consume resources and do something with them, either displaying them to humans, transferring them to some other format for further re-use, or using them to drive some kind of application logic process AKA decision support. Resource Consumers often store resources, but do not need to, and whether resources are stored or not between receiving them and using them doesn't make any difference to the obligations",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "able-to-populate",
      "display" : "be able to populate",
      "definition" : "Conformant applications producing resources SHALL/SHOULD/MAY be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        }
      ]
    },
    {
      "code" : "populate-if-known",
      "display" : "populate if known",
      "definition" : "Conformant applications producing resources SHALL/SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "populate",
      "display" : "populate",
      "definition" : "Conformant applications producing resources SHALL/SHOULD include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "populate-if-known"
        },
        {
          "code" : "parent",
          "valueCode" : "able-to-populate"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "in-narrative",
      "display" : "include in narrative",
      "definition" : "Conformant applications SHALL/SHOULD/MAY ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions such as [DataAbsentReason](StructureDefinition-data-absent-reason.html). If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "exclude-narrative",
      "display" : "exclude from narrative",
      "definition" : "Conformant applications SHALL/SHOULD ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        }
      ]
    },
    {
      "code" : "user-input",
      "display" : "allow user input",
      "definition" : "Conformant applications SHALL/SHOULD/MAY ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        }
      ]
    },
    {
      "code" : "explain",
      "display" : "populate or document irrelevance",
      "definition" : "Documentation applicable to Conformant applications SHALL/SHOULD explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element `populate`, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though *not all*) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        }
      ]
    },
    {
      "code" : "persist",
      "display" : "persist",
      "definition" : "Conformant applications SHALL/SHOULD/MAY ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceProducerObligations"
        }
      ]
    },
    {
      "code" : "no-alter",
      "display" : "not alter",
      "definition" : "Conformant applications SHALL/SHOULD ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceExchangerObligations"
        },
        {
          "code" : "converse",
          "valueCode" : "may-alter"
        }
      ]
    },
    {
      "code" : "no-error",
      "display" : "not error if present",
      "definition" : "Conformant applications SHALL/SHOULD accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        }
      ]
    },
    {
      "code" : "reject-invalid",
      "display" : "reject invalid",
      "definition" : "Conformant applications SHALL/SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL/SHOULD not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        },
        {
          "code" : "converse",
          "valueCode" : "accept-invalid"
        }
      ]
    },
    {
      "code" : "accept-invalid",
      "display" : "accept invalid",
      "definition" : "Conformant applications SHALL/SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        },
        {
          "code" : "converse",
          "valueCode" : "reject-invalid"
        }
      ]
    },
    {
      "code" : "handle",
      "display" : "correctly handle",
      "definition" : "Conformant applications SHALL/SHOULD handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        }
      ]
    },
    {
      "code" : "display",
      "display" : "display",
      "definition" : "Conformant applications SHALL/SHOULD/MAY display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "handle"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "process",
      "display" : "process",
      "definition" : "Conformant applications SHALL/SHOULD/MAY consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "handle"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "print",
      "display" : "print",
      "definition" : "Conformant applications SHALL/SHOULD/MAY print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "handle"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "ignore",
      "display" : "ignore",
      "definition" : "Conformant applications SHALL/SHOULD/MAY not make any use of the value of this element if received.",
      "property" : [
        {
          "code" : "not-selectable",
          "valueBoolean" : true
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceConsumerObligations"
        },
        {
          "code" : "converse",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "SHALL:able-to-populate",
      "display" : "SHALL be able to populate",
      "definition" : "Conformant applications producing resources SHALL be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it can be in at least some situations.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "able-to-populate"
        }
      ]
    },
    {
      "code" : "SHOULD:able-to-populate",
      "display" : "SHOULD be able to populate",
      "definition" : "Conformant applications producing resources SHOULD be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it shold be in at least some situations.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "able-to-populate"
        }
      ]
    },
    {
      "code" : "MAY:able-to-populate",
      "display" : "MAY be able to populate",
      "definition" : "Conformant applications producing resources MAY be able to correctly populate this element.\nNotes: Typically, this means that an application needs to demonstrate during some conformance testing process that there are some conditions under which it populates the element with a correct value. (i.e. not a data-absent-reason or equivalent.) This obligation does not impose expectations on the circumstances in which the element will be sent, only that it may be in at least some situations. This is a null statement and is the default behavior for originating systems if other obligations are not specified.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "able-to-populate"
        }
      ]
    },
    {
      "code" : "SHALL:populate-if-known",
      "display" : "SHALL populate if known",
      "definition" : "Conformant applications producing resources SHALL correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "populate-if-known"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:populate-if-known",
      "display" : "SHOULD populate if known",
      "definition" : "Conformant applications producing resources SHOULD correctly populate this element if they know a value for the element, but it is acceptable if the system is unable to ever know a value for the element.\nNotes: This obligation does not impose a requirement to be able to know a value, unlike populate and able-to-populate which do. 'Knowing' an element means that a value for the element is available in memory, persistent store, or is otherwise available within the system claiming conformance.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "populate-if-known"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:populate",
      "display" : "SHALL populate",
      "definition" : "Conformant applications producing resources SHALL include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it populates it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:able-to-populate"
        },
        {
          "code" : "parent",
          "valueCode" : "populate"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:populate",
      "display" : "SHOULD populate",
      "definition" : "Conformant applications producing resources SHOULD include this element if a value is known and allowed to be shared.\nNotes: This implementation obligation means that whenever the producer knows the correct value for an element, it should populate it. This is NOT the same as cardinality, as a 'populate' element can be omitted if no data exists or the data that exists is prohibited from being shared.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:able-to-populate"
        },
        {
          "code" : "parent",
          "valueCode" : "populate"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:in-narrative",
      "display" : "SHALL include in narrative",
      "definition" : "Conformant applications SHALL ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions such as [DataAbsentReason](StructureDefinition-data-absent-reason.html). If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "in-narrative"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:in-narrative",
      "display" : "SHOULD include in narrative",
      "definition" : "Conformant applications SHOULD ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions such as [DataAbsentReason](StructureDefinition-data-absent-reason.html). If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "in-narrative"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "MAY:in-narrative",
      "display" : "MAY include in narrative",
      "definition" : "Conformant applications MAY ensure that this data element is represented in any human readable representation of a resource.\nNotes: When no value for an element is known, the producer populates the narrative with the content of any nested [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions such as [DataAbsentReason](StructureDefinition-data-absent-reason.html). If no particular reason is known or reportable, the element can simply be indicated as 'unknown' in the narrative.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "in-narrative"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:exclude-narrative",
      "display" : "SHALL exclude from narrative",
      "definition" : "Conformant applications SHALL ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "exclude-narrative"
        }
      ]
    },
    {
      "code" : "SHOULD:exclude-narrative",
      "display" : "SHOULD exclude from narrative",
      "definition" : "Conformant applications SHOULD ensure that this data element is NOT represented in any human readable representation of a resource.\nNotes: This may be useful for profiles related to de-identified records",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "exclude-narrative"
        }
      ]
    },
    {
      "code" : "SHALL:user-input",
      "display" : "SHALL allow user input",
      "definition" : "Conformant applications SHALL ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "user-input"
        }
      ]
    },
    {
      "code" : "SHOULD:user-input",
      "display" : "SHOULD allow user input",
      "definition" : "Conformant applications SHOULD ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "user-input"
        }
      ]
    },
    {
      "code" : "MAY:user-input",
      "display" : "MAY allow user input",
      "definition" : "Conformant applications MAY ensure that users can enter a value for this element during data input/capture.\nNotes: Exactly what form the input takes is not specified, but the expectation is that this is a value that comes from the user, and not implied internally by the application.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "user-input"
        }
      ]
    },
    {
      "code" : "SHALL:explain",
      "display" : "SHALL populate or document irrelevance",
      "definition" : "Documentation applicable to Conformant applications SHALL explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element `populate`, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though *not all*) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "explain"
        }
      ]
    },
    {
      "code" : "SHOULD:explain",
      "display" : "SHOULD populate or document irrelevance",
      "definition" : "Documentation applicable to Conformant applications SHOULD explain how this element is handled.\nNotes: this is really a rule about specifications, implying that another specification (which might be application documentation) either makes this element `populate`, or explains how the use cases that involve this element do not arise, or how they are handled. An example: IPA marks Patient.active must-handle and must-explain. Client applications must process Patient.active correctly if they see it, but many (though *not all*) specifications and/or applications ensure that Patient.active will never be false, and so it will never be populated e.g. MedMij in Netherlands prohibits use of Patient.active, and explains that it is never false.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "explain"
        }
      ]
    },
    {
      "code" : "SHALL:persist",
      "display" : "SHALL persist",
      "definition" : "Conformant applications SHALL ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "persist"
        }
      ]
    },
    {
      "code" : "SHOULD:persist",
      "display" : "SHOULD persist",
      "definition" : "Conformant applications SHOULD ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "persist"
        }
      ]
    },
    {
      "code" : "MAY:persist",
      "display" : "MAY persist",
      "definition" : "Conformant applications MAY ensure that the value for this element is stored in a persistent data store.\nNotes: Exactly what the data store is not specified, nor how long it is stored for, but it is understood that the same value will be available in later exchanges",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "persist"
        }
      ]
    },
    {
      "code" : "SHALL:no-alter",
      "display" : "SHALL not alter",
      "definition" : "Conformant applications SHALL ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "no-alter"
        },
        {
          "code" : "converse",
          "valueCode" : "may-alter"
        }
      ]
    },
    {
      "code" : "SHOULD:no-alter",
      "display" : "SHOULD not alter",
      "definition" : "Conformant applications SHOULD ensure that this element does not change between receiving and transfer.\nNotes: This does not mean that the element value cannot change, only that changing the element value for an element marked with this obligation moves an application from being an exchanger to a Consumer and a Producer, and those obligations apply",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "no-alter"
        },
        {
          "code" : "converse",
          "valueCode" : "may-alter"
        }
      ]
    },
    {
      "code" : "MAY:alter",
      "display" : "MAY alter",
      "definition" : "Conformant applications MAY choose to alter this element value.\nNotes: this is really a null-statement - it's the default rule for an application. It's defined here to allow a specification to be explicit that it isn't conveying obligations for resource producers",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "ResourceExchangerObligations"
        },
        {
          "code" : "converse",
          "valueCode" : "no-alter"
        }
      ]
    },
    {
      "code" : "SHALL:no-error",
      "display" : "SHALL not error if present",
      "definition" : "Conformant applications SHALL accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "no-error"
        }
      ]
    },
    {
      "code" : "SHOULD:no-error",
      "display" : "SHOULD not error if present",
      "definition" : "Conformant applications SHOULD accept resources containing any valid value for the element without error.\nNotes: Applications are still able to inform the user that a value cannot be processed correctly and may ignore the data, but applications aren't able to reject an instance merely because the element is present (which would be allowed for elements that do not have this obligation). A system MAY raise an error if the value provided is not valid or violates specific business rules. This obligation also applies to elements that only contain an extension in place of a value where (or equivalent), should either of these be allowed on the consumer obligations",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "no-error"
        }
      ]
    },
    {
      "code" : "SHALL:reject-invalid",
      "display" : "SHALL reject invalid",
      "definition" : "Conformant applications SHALL check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHALL not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "reject-invalid"
        },
        {
          "code" : "converse",
          "valueCode" : "accept-invalid"
        }
      ]
    },
    {
      "code" : "SHOULD:reject-invalid",
      "display" : "SHOULD reject invalid",
      "definition" : "Conformant applications SHOULD check that values for this element meet all data constraints asserted within the profile declaring this obligation. If validity issues are found, the system SHOULD not accept the instance.\nNotes: This applies to validating the element with the obligation, but not resources referenced by it.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "reject-invalid"
        },
        {
          "code" : "converse",
          "valueCode" : "accept-invalid"
        }
      ]
    },
    {
      "code" : "SHALL:accept-invalid",
      "display" : "SHALL accept invalid",
      "definition" : "Conformant applications SHALL accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system needs to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "accept-invalid"
        },
        {
          "code" : "converse",
          "valueCode" : "reject-invalid"
        }
      ]
    },
    {
      "code" : "SHOULD:accept-invalid",
      "display" : "SHOULD accept invalid",
      "definition" : "Conformant applications SHOULD accept data that does not meet all data constraints asserted within the profile declaring this obligation.\nThis applies to non-valid constraints, not to non-valid syntax or failure to meet base resource validity expectations. Typically used when a system ought to be able to handle data that does not adhere to desired expectations (legacy data, test data, data undergoing authorship that is not yet complete, etc.)",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "accept-invalid"
        },
        {
          "code" : "converse",
          "valueCode" : "reject-invalid"
        }
      ]
    },
    {
      "code" : "SHALL:handle",
      "display" : "SHALL correctly handle",
      "definition" : "Conformant applications SHALL handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "SHOULD:handle",
      "display" : "SHOULD correctly handle",
      "definition" : "Conformant applications SHOULD handle the meaning of this element correctly.\nNotes: this rule is vague in that doesn't specify any particular handling of the element. But it's important because an application that ignores this element is non-conformant. A good example would be a status code of 'entered-in-error' - how exactly a Resource Consumer handles this depends on the use case etc., but the application can never simply ignore such a status code. Note that whether the resource or information from it is stored for later use is irrelevant - when the resource or information in it is processed, the consequences of the element are considered. That may mean not retaining the information for later use, or informing the user, etc. Typically, this obligation marks that there are known patient safety issues that can arise if the element is ignored. Implementers should pay particular attention to the possible range of values for the element from a safety perspective.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "SHALL:display",
      "display" : "SHALL display",
      "definition" : "Conformant applications SHALL display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "display"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:display",
      "display" : "SHOULD display",
      "definition" : "Conformant applications SHOULD display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "display"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "MAY:display",
      "display" : "MAY display",
      "definition" : "Conformant applications MAY display the value of this element when presenting the data from the resource to a human user.\nNotes: exactly how it is displayed is not specified, but it means that a human looking at the content of the resource is made aware of the value of the element so that they can consider the meaning of the resource",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "display"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:process",
      "display" : "SHALL process",
      "definition" : "Conformant applications SHALL consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "process"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:process",
      "display" : "SHOULD process",
      "definition" : "Conformant applications SHOULD consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "process"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "MAY:process",
      "display" : "MAY process",
      "definition" : "Conformant applications MAY consider the value of this element when processing the resource as specified by the IG.\nNotes: this implies that the IG that specifies this obligation provides details about what processing is to be performed, and the obligation specifially relates to the processing specified in the IG of any [ElementDefinition.valueAlternatives](http://hl7.org/fhir/R5/elementdefinition-definitions.html#ElementDefinition.valueAlternatives) extensions as well as the value (or other extensions explicitly declared beneath the element in the profile containing the obligation. Examples might include consideration in decision support, consideration in claims evaluation, etc.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "process"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:print",
      "display" : "SHALL print",
      "definition" : "Conformant applications SHALL print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "print"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHOULD:print",
      "display" : "SHOULD print",
      "definition" : "Conformant applications SHOULD print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:handle"
        },
        {
          "code" : "parent",
          "valueCode" : "print"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "MAY:print",
      "display" : "MAY print",
      "definition" : "Conformant applications MAY print the value of this element somewhere.\nNotes: The form of the printing is not specified. A profile using this value SHALL explain the nature of the printing requirement somehow",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "print"
        },
        {
          "code" : "security-dependent",
          "valueBoolean" : true
        }
      ]
    },
    {
      "code" : "SHALL:ignore",
      "display" : "SHALL ignore",
      "definition" : "Conformant applications SHALL not make any use of the value of this element if received.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHALL"
        },
        {
          "code" : "parent",
          "valueCode" : "ignore"
        },
        {
          "code" : "converse",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "SHOULD:ignore",
      "display" : "SHOULD ignore",
      "definition" : "Conformant applications SHOULD not make any use of the value of this element if received.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "SHOULD"
        },
        {
          "code" : "parent",
          "valueCode" : "ignore"
        },
        {
          "code" : "converse",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "MAY:ignore",
      "display" : "MAY ignore",
      "definition" : "Conformant applications MAY not make any use of the value of this element if received. This is a null statement and is the default behavior or consuming systems if other obligations are not specified.",
      "property" : [
        {
          "code" : "qualifier",
          "valueCode" : "MAY"
        },
        {
          "code" : "parent",
          "valueCode" : "ignore"
        },
        {
          "code" : "converse",
          "valueCode" : "handle"
        }
      ]
    },
    {
      "code" : "v2-re",
      "display" : "V2 RE (required but may be empty)",
      "definition" : "RE as defined in chapter 2 of the v2 specification",
      "property" : [
        {
          "code" : "parent",
          "valueCode" : "SHALL:able-to-populate"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:display"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:persist"
        },
        {
          "code" : "parent",
          "valueCode" : "SHOULD:populate"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:no-error"
        }
      ]
    },
    {
      "code" : "ihe-r2",
      "display" : "IHE R2",
      "definition" : "R2 as defined in IHE Appendix Z",
      "property" : [
        {
          "code" : "parent",
          "valueCode" : "SHALL:populate"
        },
        {
          "code" : "parent",
          "valueCode" : "MAY:ignore"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:no-error"
        }
      ]
    },
    {
      "code" : "std",
      "display" : "Standard obligations",
      "definition" : "The standard recommended set of obligations for IGs to use unless they know they want something different. Note that the standard codes don't include use-dar, use-dar-nf, use-dar-if-allowed / use-reason - that gets put on specific elements that justify this handling",
      "property" : [
        {
          "code" : "parent",
          "valueCode" : "SHALL:populate"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:display"
        },
        {
          "code" : "parent",
          "valueCode" : "SHALL:no-error"
        }
      ]
    }
  ]
}

XIG built as of ??metadata-date??. Found ??metadata-resources?? resources in ??metadata-packages?? packages.